/*
 *
 */
package IA;

/**
 * autor Richardson Lima
 */

public class CalcularRede {

    /**
     * @param args the command line arguments
     */

    // pesos
    public double[] w1 = new double[26];
    public double[] w2 = new double[26];
    public double[] w3 = new double[26];
    public double[] w4 = new double[26];
 
    // variavél que faz o rede.
    public double somatorioRede = 0;
    
    // variavél do número máximo de Épocas
    public final int maxEpocas = 3000;
 
    // declara o vetor da matriz de entrada dos caracteres
    public int[][] defaultEntry = new int[9][26];
    
    // declara o vetor da matriz com a resposta para os caracteres inseridos
    public int[][] expectedOutput = new int[9][4];

    // variavél que faz a contagem Épocas
    public int contador = 0;
    public int getCount(){
 
      return this.contador;
 
    }    

    public CalcularRede() {
        
        // Letra I
        this.defaultEntry[0][0]  = 1;
        this.defaultEntry[0][1]  = 0;
        this.defaultEntry[0][2]  = 1;
        this.defaultEntry[0][3]  = 1;
        this.defaultEntry[0][4]  = 1;
        this.defaultEntry[0][5]  = 0;
        this.defaultEntry[0][6]  = 0;
        this.defaultEntry[0][7]  = 0;
        this.defaultEntry[0][8]  = 1;
        this.defaultEntry[0][9]  = 0;
        this.defaultEntry[0][10] = 0;
        this.defaultEntry[0][11] = 0;
        this.defaultEntry[0][12] = 0;
        this.defaultEntry[0][13] = 1;
        this.defaultEntry[0][14] = 0;
        this.defaultEntry[0][15] = 0;
        this.defaultEntry[0][16] = 0;
        this.defaultEntry[0][17] = 0;
        this.defaultEntry[0][18] = 1;
        this.defaultEntry[0][19] = 0;
        this.defaultEntry[0][20] = 0;
        this.defaultEntry[0][21] = 0;
        this.defaultEntry[0][22] = 1;
        this.defaultEntry[0][23] = 1;
        this.defaultEntry[0][24] = 1;
        this.defaultEntry[0][25] = 0;
   
        // Letra V
        this.defaultEntry[1][0]  = 1; 
        this.defaultEntry[1][1]  = 0; 
        this.defaultEntry[1][2]  = 0; 
        this.defaultEntry[1][3]  = 0; 
        this.defaultEntry[1][4]  = 0; 
        this.defaultEntry[1][5]  = 0; 
        this.defaultEntry[1][6]  = 1; 
        this.defaultEntry[1][7]  = 0; 
        this.defaultEntry[1][8]  = 0; 
        this.defaultEntry[1][9]  = 0; 
        this.defaultEntry[1][10] = 1; 
        this.defaultEntry[1][11] = 0; 
        this.defaultEntry[1][12] = 1; 
        this.defaultEntry[1][13] = 0; 
        this.defaultEntry[1][14] = 1; 
        this.defaultEntry[1][15] = 0; 
        this.defaultEntry[1][16] = 0; 
        this.defaultEntry[1][17] = 1; 
        this.defaultEntry[1][18] = 0; 
        this.defaultEntry[1][19] = 1; 
        this.defaultEntry[1][20] = 0; 
        this.defaultEntry[1][21] = 0; 
        this.defaultEntry[1][22] = 0; 
        this.defaultEntry[1][23] = 1; 
        this.defaultEntry[1][24] = 0;
        this.defaultEntry[1][25] = 0;

        // Letra G
        this.defaultEntry[2][0]  = 1; 
        this.defaultEntry[2][1]  = 1; 
        this.defaultEntry[2][2]  = 1; 
        this.defaultEntry[2][3]  = 1; 
        this.defaultEntry[2][4]  = 1; 
        this.defaultEntry[2][5]  = 0; 
        this.defaultEntry[2][6]  = 1; 
        this.defaultEntry[2][7]  = 0; 
        this.defaultEntry[2][8]  = 0; 
        this.defaultEntry[2][9]  = 0; 
        this.defaultEntry[2][10] = 0; 
        this.defaultEntry[2][11] = 1; 
        this.defaultEntry[2][12] = 0; 
        this.defaultEntry[2][13] = 1; 
        this.defaultEntry[2][14] = 1; 
        this.defaultEntry[2][15] = 1; 
        this.defaultEntry[2][16] = 1; 
        this.defaultEntry[2][17] = 0; 
        this.defaultEntry[2][18] = 0; 
        this.defaultEntry[2][19] = 1; 
        this.defaultEntry[2][20] = 0; 
        this.defaultEntry[2][21] = 1; 
        this.defaultEntry[2][22] = 1; 
        this.defaultEntry[2][23] = 1; 
        this.defaultEntry[2][24] = 1;
        this.defaultEntry[2][25] = 0;
        
        //  Letra U
        this.defaultEntry[3][0]  = 1; 
        this.defaultEntry[3][1]  = 0; 
        this.defaultEntry[3][2]  = 1; 
        this.defaultEntry[3][3]  = 0; 
        this.defaultEntry[3][4]  = 1; 
        this.defaultEntry[3][5]  = 0; 
        this.defaultEntry[3][6]  = 0; 
        this.defaultEntry[3][7]  = 1; 
        this.defaultEntry[3][8]  = 0; 
        this.defaultEntry[3][9]  = 1; 
        this.defaultEntry[3][10] = 0; 
        this.defaultEntry[3][11] = 0; 
        this.defaultEntry[3][12] = 1; 
        this.defaultEntry[3][13] = 0; 
        this.defaultEntry[3][14] = 1; 
        this.defaultEntry[3][15] = 0; 
        this.defaultEntry[3][16] = 0; 
        this.defaultEntry[3][17] = 1; 
        this.defaultEntry[3][18] = 0; 
        this.defaultEntry[3][19] = 1; 
        this.defaultEntry[3][20] = 0; 
        this.defaultEntry[3][21] = 0; 
        this.defaultEntry[3][22] = 1; 
        this.defaultEntry[3][23] = 1; 
        this.defaultEntry[3][24] = 1;
        this.defaultEntry[3][25] = 0;

        //  Letra  E
        this.defaultEntry[4][0]  = 1; 
        this.defaultEntry[4][1]  = 1; 
        this.defaultEntry[4][2]  = 1; 
        this.defaultEntry[4][3]  = 1; 
        this.defaultEntry[4][4]  = 1; 
        this.defaultEntry[4][5]  = 0; 
        this.defaultEntry[4][6]  = 1; 
        this.defaultEntry[4][7]  = 0; 
        this.defaultEntry[4][8]  = 0; 
        this.defaultEntry[4][9]  = 0; 
        this.defaultEntry[4][10] = 0; 
        this.defaultEntry[4][11] = 1; 
        this.defaultEntry[4][12] = 1; 
        this.defaultEntry[4][13] = 1; 
        this.defaultEntry[4][14] = 0; 
        this.defaultEntry[4][15] = 0; 
        this.defaultEntry[4][16] = 1; 
        this.defaultEntry[4][17] = 0; 
        this.defaultEntry[4][18] = 0; 
        this.defaultEntry[4][19] = 0; 
        this.defaultEntry[4][20] = 0; 
        this.defaultEntry[4][21] = 1; 
        this.defaultEntry[4][22] = 1; 
        this.defaultEntry[4][23] = 1; 
        this.defaultEntry[4][24] = 1;
        this.defaultEntry[4][25] = 0;

        // Letra W
        this.defaultEntry[5][0]  = 1; 
        this.defaultEntry[5][1]  = 1; 
        this.defaultEntry[5][2]  = 0; 
        this.defaultEntry[5][3]  = 0; 
        this.defaultEntry[5][4]  = 0; 
        this.defaultEntry[5][5]  = 1; 
        this.defaultEntry[5][6]  = 1; 
        this.defaultEntry[5][7]  = 0; 
        this.defaultEntry[5][8]  = 0; 
        this.defaultEntry[5][9]  = 0; 
        this.defaultEntry[5][10] = 1; 
        this.defaultEntry[5][11] = 1; 
        this.defaultEntry[5][12] = 0; 
        this.defaultEntry[5][13] = 1; 
        this.defaultEntry[5][14] = 0; 
        this.defaultEntry[5][15] = 1; 
        this.defaultEntry[5][16] = 1; 
        this.defaultEntry[5][17] = 1; 
        this.defaultEntry[5][18] = 0; 
        this.defaultEntry[5][19] = 1; 
        this.defaultEntry[5][20] = 1; 
        this.defaultEntry[5][21] = 1; 
        this.defaultEntry[5][22] = 0; 
        this.defaultEntry[5][23] = 0; 
        this.defaultEntry[5][24] = 0;
        this.defaultEntry[5][25] = 1;

        // Numero 7
        this.defaultEntry[6][0]  = 1; 
        this.defaultEntry[6][1]  = 0; 
        this.defaultEntry[6][2]  = 1; 
        this.defaultEntry[6][3]  = 1; 
        this.defaultEntry[6][4]  = 1; 
        this.defaultEntry[6][5]  = 0; 
        this.defaultEntry[6][6]  = 0; 
        this.defaultEntry[6][7]  = 0; 
        this.defaultEntry[6][8]  = 0; 
        this.defaultEntry[6][9]  = 1; 
        this.defaultEntry[6][10] = 0; 
        this.defaultEntry[6][11] = 0; 
        this.defaultEntry[6][12] = 0; 
        this.defaultEntry[6][13] = 0; 
        this.defaultEntry[6][14] = 1; 
        this.defaultEntry[6][15] = 0; 
        this.defaultEntry[6][16] = 0; 
        this.defaultEntry[6][17] = 0; 
        this.defaultEntry[6][18] = 0; 
        this.defaultEntry[6][19] = 1; 
        this.defaultEntry[6][20] = 0; 
        this.defaultEntry[6][21] = 0; 
        this.defaultEntry[6][22] = 0; 
        this.defaultEntry[6][23] = 0; 
        this.defaultEntry[6][24] = 1;
        this.defaultEntry[6][25] = 0;

        //  Numero 6
        this.defaultEntry[7][0]  = 1; 
        this.defaultEntry[7][1]  = 1; 
        this.defaultEntry[7][2]  = 1; 
        this.defaultEntry[7][3]  = 1; 
        this.defaultEntry[7][4]  = 1; 
        this.defaultEntry[7][5]  = 0; 
        this.defaultEntry[7][6]  = 1; 
        this.defaultEntry[7][7]  = 0; 
        this.defaultEntry[7][8]  = 0; 
        this.defaultEntry[7][9]  = 0; 
        this.defaultEntry[7][10] = 0; 
        this.defaultEntry[7][11] = 1; 
        this.defaultEntry[7][12] = 1; 
        this.defaultEntry[7][13] = 1; 
        this.defaultEntry[7][14] = 1; 
        this.defaultEntry[7][15] = 0; 
        this.defaultEntry[7][16] = 1; 
        this.defaultEntry[7][17] = 0; 
        this.defaultEntry[7][18] = 0; 
        this.defaultEntry[7][19] = 1; 
        this.defaultEntry[7][20] = 0; 
        this.defaultEntry[7][21] = 1; 
        this.defaultEntry[7][22] = 1; 
        this.defaultEntry[7][23] = 1; 
        this.defaultEntry[7][24] = 1;
        this.defaultEntry[7][25] = 0;
        
        // Saida letra I
        this.expectedOutput[0][0]  = 0;
        this.expectedOutput[0][1]  = 0;
        this.expectedOutput[0][2]  = 0;
        this.expectedOutput[0][3]  = 0;
        
        // Saida letra V
        this.expectedOutput[1][0]  = 0;
        this.expectedOutput[1][1]  = 0;
        this.expectedOutput[1][2]  = 0;
        this.expectedOutput[1][3]  = 1;

        // Saida letra G
        this.expectedOutput[2][0]  = 0;
        this.expectedOutput[2][1]  = 0;
        this.expectedOutput[2][2]  = 1;
        this.expectedOutput[2][3]  = 0;

        // Saida letra U
        this.expectedOutput[3][0]  = 0;
        this.expectedOutput[3][1]  = 0;
        this.expectedOutput[3][2]  = 1;
        this.expectedOutput[3][3]  = 1;

        // Saida letra E
        this.expectedOutput[4][0]  = 0;
        this.expectedOutput[4][1]  = 1;
        this.expectedOutput[4][2]  = 0;
        this.expectedOutput[4][3]  = 0;
        
        // Saida letra W
        this.expectedOutput[5][0]  = 0;
        this.expectedOutput[5][1]  = 1;
        this.expectedOutput[5][2]  = 0;
        this.expectedOutput[5][3]  = 1;
        
        // Saida numero 7
        this.expectedOutput[6][0]  = 0;
        this.expectedOutput[6][1]  = 1;
        this.expectedOutput[6][2]  = 1;
        this.expectedOutput[6][3]  = 0;

        // Saida numero 6
        this.expectedOutput[7][0]  = 0;
        this.expectedOutput[7][1]  = 1;
        this.expectedOutput[7][2]  = 1;
        this.expectedOutput[7][3]  = 1;


        // Inicializar Pesos
        w1[0] = 0;
        w1[1] = 0;
        w1[2] = 0;
        w1[3] = 0;
        w1[4] = 0;
        w1[5] = 0;
        w1[6] = 0;
        w1[7] = 0;
        w1[8] = 0;
        w1[9] = 0;
        w1[10] = 0;
        w1[11] = 0;
        w1[12] = 0;
        w1[13] = 0;
        w1[14] = 0;
        w1[15] = 0;
        w1[16] = 0;
        w1[17] = 0;
        w1[18] = 0;
        w1[19] = 0;
        w1[20] = 0;
        w1[21] = 0;
        w1[22] = 0;
        w1[23] = 0;
        w1[24] = 0;
        w1[25] = 0;

        w2[0] = 0;
        w2[1] = 0;
        w2[2] = 0;
        w2[3] = 0;
        w2[4] = 0;
        w2[5] = 0;
        w2[6] = 0;
        w2[7] = 0;
        w2[8] = 0;
        w2[9] = 0;
        w2[10] = 0;
        w2[11] = 0;
        w2[12] = 0;
        w2[13] = 0;
        w2[14] = 0;
        w2[15] = 0;
        w2[16] = 0;
        w2[17] = 0;
        w2[18] = 0;
        w2[19] = 0;
        w2[20] = 0;
        w2[21] = 0;
        w2[22] = 0;
        w2[23] = 0;
        w2[24] = 0;
        w2[25] = 0;
    
        w3[0] = 0;
        w3[1] = 0;
        w3[2] = 0;
        w3[3] = 0;
        w3[4] = 0;
        w3[5] = 0;
        w3[6] = 0;
        w3[7] = 0;
        w3[8] = 0;
        w3[9] = 0;
        w3[10] = 0;
        w3[11] = 0;
        w3[12] = 0;
        w3[13] = 0;
        w3[14] = 0;
        w3[15] = 0;
        w3[16] = 0;
        w3[17] = 0;
        w3[18] = 0;
        w3[19] = 0;
        w3[20] = 0;
        w3[21] = 0;
        w3[22] = 0;
        w3[23] = 0;
        w3[24] = 0;
        w3[25] = 0;

        w4[0] = 0;
        w4[1] = 0;
        w4[2] = 0;
        w4[3] = 0;
        w4[4] = 0;
        w4[5] = 0;
        w4[6] = 0;
        w4[7] = 0;
        w4[8] = 0;
        w4[9] = 0;
        w4[10] = 0;
        w4[11] = 0;
        w4[12] = 0;
        w4[13] = 0;
        w4[14] = 0;
        w4[15] = 0;
        w4[16] = 0;
        w4[17] = 0;
        w4[18] = 0;
        w4[19] = 0;
        w4[20] = 0;
        w4[21] = 0;
        w4[22] = 0;
        w4[23] = 0;
        w4[24] = 0;
        w4[25] = 0;
       
    }    
    
    int CalculoNeuronio1(int[] entradas){
        somatorioRede = 0;
        
        for(int n = 0 ; n < 26 ; n++){
            somatorioRede += ( w1[n] * entradas[n] );
        }
        
        if (somatorioRede >= 0) {
            return 1;
        }
        return 0;
    }
    
    int CalculoNeuronio2(int[] entradas){
        somatorioRede = 0;
        
        for(int n = 0 ; n < 26 ; n++){
            somatorioRede += ( w2[n] * entradas[n] );
        }
        
        if (somatorioRede >= 0) {
            return 1;
        }
        return 0;
    }

    int CalculoNeuronio3(int[] entradas){
        somatorioRede = 0;
        
        for(int n = 0 ; n < 26 ; n++){
            somatorioRede += ( w3[n] * entradas[n] );
        }
        
        if (somatorioRede >= 0) {
            return 1;
        }
        return 0;
    }

    int CalculoNeuronio4(int[] entradas){
        somatorioRede = 0;
        
        for(int n = 0 ; n < 26 ; n++){
            somatorioRede += ( w4[n] * entradas[n] );
        }
        
        if (somatorioRede >= 0) {
            return 1;
        }
        return 0;
    }
    
    // treinar rede
    public void treinar() {
 
        // variavel utilizada para controle de treinamento
        boolean treinou= true;
        
        // varável utilizada para receber resposta do calculo
        int resultado1;
        int resultado2;
        int resultado3;
        int resultado4;
 
        // loop para treinar todos os caracteres desejados
        for (int i = 0; i < 9; i++) {

            // A saída recebe o resultado da rede que no caso é 1 ou 0
            resultado1 = CalculoNeuronio1(defaultEntry[i]);
            
            // identificando se o resultado obtido é igual ao desejado
            if (resultado1 != expectedOutput[i][0]) {

                // se os valores forem difrentes os pesos serão recalculados
                RecalcularPeso1(i, resultado1);
                // ao corrigir os pesos a variavel recebe o valor de falso
                treinou = false;

            }

            resultado2 = CalculoNeuronio2(defaultEntry[i]);
            
            // identificando se o resultado obitdo é igual ao desejado
            if (resultado2 != expectedOutput[i][1]) {

                // se os valores forem difrentes os pesos serão recalculados
                RecalcularPeso2(i, resultado2);
                // ao corrigir os pesos a variavel recebe o valor de falso
                treinou = false;

            }
            
            resultado3 = CalculoNeuronio3(defaultEntry[i]);
            
            // identificando se o resultado obitdo é igual ao desejado
            if (resultado3 != expectedOutput[i][2]) {

                // se os valores forem difrentes os pesos serão recalculados
                RecalcularPeso3(i, resultado3);
                // ao corrigir os pesos a variavel recebe o valor de falso
                treinou = false;

            }

            resultado4 = CalculoNeuronio4(defaultEntry[i]);
            
            // identificando se o resultado obitdo é igual ao desejado
            if (resultado4 != expectedOutput[i][3]) {

                // se os valores forem difrentes os pesos serão recalculados
                RecalcularPeso4(i, resultado4);
                // ao corrigir os pesos a variavel recebe o valor de falso
                treinou = false;

            }

        }

        // soma ao contador de epocas mais uma epoca
        this.contador++;
 
        /* testa se houve algum erro duranteo treinamento e se número de epocas
        é menor que o minimo*/
        if((treinou == false) && (this.contador < this.maxEpocas)) {
            // chamada recursiva do método
            treinar();
        System.out.println(contador);
        }
    
    }    // fim do método para treinamento
    

    // Método para o recalcular os pesos
    void RecalcularPeso1(int i, int resultado) {

        w1[0]  = w1[0]  + (1 * (expectedOutput[i][0] - resultado) * defaultEntry[i][0]);
        w1[1]  = w1[1]  + (1 * (expectedOutput[i][0] - resultado) * defaultEntry[i][1]);
        w1[2]  = w1[2]  + (1 * (expectedOutput[i][0] - resultado) * defaultEntry[i][2]);
        w1[3]  = w1[3]  + (1 * (expectedOutput[i][0] - resultado) * defaultEntry[i][3]);
        w1[4]  = w1[4]  + (1 * (expectedOutput[i][0] - resultado) * defaultEntry[i][4]);
        w1[5]  = w1[5]  + (1 * (expectedOutput[i][0] - resultado) * defaultEntry[i][5]);
        w1[6]  = w1[6]  + (1 * (expectedOutput[i][0] - resultado) * defaultEntry[i][6]);
        w1[7]  = w1[7]  + (1 * (expectedOutput[i][0] - resultado) * defaultEntry[i][7]);
        w1[8]  = w1[8]  + (1 * (expectedOutput[i][0] - resultado) * defaultEntry[i][8]);
        w1[9]  = w1[9]  + (1 * (expectedOutput[i][0] - resultado) * defaultEntry[i][9]);
        w1[10] = w1[10] + (1 * (expectedOutput[i][0] - resultado) * defaultEntry[i][10]);
        w1[11] = w1[11] + (1 * (expectedOutput[i][0] - resultado) * defaultEntry[i][11]);
        w1[12] = w1[12] + (1 * (expectedOutput[i][0] - resultado) * defaultEntry[i][12]);
        w1[13] = w1[13] + (1 * (expectedOutput[i][0] - resultado) * defaultEntry[i][13]);
        w1[14] = w1[14] + (1 * (expectedOutput[i][0] - resultado) * defaultEntry[i][14]);
        w1[15] = w1[15] + (1 * (expectedOutput[i][0] - resultado) * defaultEntry[i][15]);
        w1[16] = w1[16] + (1 * (expectedOutput[i][0] - resultado) * defaultEntry[i][16]);
        w1[17] = w1[17] + (1 * (expectedOutput[i][0] - resultado) * defaultEntry[i][17]);
        w1[18] = w1[18] + (1 * (expectedOutput[i][0] - resultado) * defaultEntry[i][18]);
        w1[19] = w1[19] + (1 * (expectedOutput[i][0] - resultado) * defaultEntry[i][19]);
        w1[20] = w1[20] + (1 * (expectedOutput[i][0] - resultado) * defaultEntry[i][20]);
        w1[21] = w1[21] + (1 * (expectedOutput[i][0] - resultado) * defaultEntry[i][21]);
        w1[22] = w1[22] + (1 * (expectedOutput[i][0] - resultado) * defaultEntry[i][22]);
        w1[23] = w1[23] + (1 * (expectedOutput[i][0] - resultado) * defaultEntry[i][23]);
        w1[24] = w1[24] + (1 * (expectedOutput[i][0] - resultado) * defaultEntry[i][24]);
        w1[25] = w1[25] + (1 * (expectedOutput[i][0] - resultado) * defaultEntry[i][24]);
    }
    
    void RecalcularPeso2(int i, int resultado) {

        w2[0]  = w2[0]  + (1 * (expectedOutput[i][1] - resultado) * defaultEntry[i][0]);
        w2[1]  = w2[1]  + (1 * (expectedOutput[i][1] - resultado) * defaultEntry[i][1]);
        w2[2]  = w2[2]  + (1 * (expectedOutput[i][1] - resultado) * defaultEntry[i][2]);
        w2[3]  = w2[3]  + (1 * (expectedOutput[i][1] - resultado) * defaultEntry[i][3]);
        w2[4]  = w2[4]  + (1 * (expectedOutput[i][1] - resultado) * defaultEntry[i][4]);
        w2[5]  = w2[5]  + (1 * (expectedOutput[i][1] - resultado) * defaultEntry[i][5]);
        w2[6]  = w2[6]  + (1 * (expectedOutput[i][1] - resultado) * defaultEntry[i][6]);
        w2[7]  = w2[7]  + (1 * (expectedOutput[i][1] - resultado) * defaultEntry[i][7]);
        w2[8]  = w2[8]  + (1 * (expectedOutput[i][1] - resultado) * defaultEntry[i][8]);
        w2[9]  = w2[9]  + (1 * (expectedOutput[i][1] - resultado) * defaultEntry[i][9]);
        w2[10] = w2[10] + (1 * (expectedOutput[i][1] - resultado) * defaultEntry[i][10]);
        w2[11] = w2[11] + (1 * (expectedOutput[i][1] - resultado) * defaultEntry[i][11]);
        w2[12] = w2[12] + (1 * (expectedOutput[i][1] - resultado) * defaultEntry[i][12]);
        w2[13] = w2[13] + (1 * (expectedOutput[i][1] - resultado) * defaultEntry[i][13]);
        w2[14] = w2[14] + (1 * (expectedOutput[i][1] - resultado) * defaultEntry[i][14]);
        w2[15] = w2[15] + (1 * (expectedOutput[i][1] - resultado) * defaultEntry[i][15]);
        w2[16] = w2[16] + (1 * (expectedOutput[i][1] - resultado) * defaultEntry[i][16]);
        w2[17] = w2[17] + (1 * (expectedOutput[i][1] - resultado) * defaultEntry[i][17]);
        w2[18] = w2[18] + (1 * (expectedOutput[i][1] - resultado) * defaultEntry[i][18]);
        w2[19] = w2[19] + (1 * (expectedOutput[i][1] - resultado) * defaultEntry[i][19]);
        w2[20] = w2[20] + (1 * (expectedOutput[i][1] - resultado) * defaultEntry[i][20]);
        w2[21] = w2[21] + (1 * (expectedOutput[i][1] - resultado) * defaultEntry[i][21]);
        w2[22] = w2[22] + (1 * (expectedOutput[i][1] - resultado) * defaultEntry[i][22]);
        w2[23] = w2[23] + (1 * (expectedOutput[i][1] - resultado) * defaultEntry[i][23]);
        w2[24] = w2[24] + (1 * (expectedOutput[i][1] - resultado) * defaultEntry[i][24]);
        w2[25] = w2[25] + (1 * (expectedOutput[i][1] - resultado) * defaultEntry[i][25]);
    }

    void RecalcularPeso3(int i, int resultado ){

        w3[0]  = w3[0]  + (1 * (expectedOutput[i][2] - resultado) * defaultEntry[i][0]);
        w3[1]  = w3[1]  + (1 * (expectedOutput[i][2] - resultado) * defaultEntry[i][1]);
        w3[2]  = w3[2]  + (1 * (expectedOutput[i][2] - resultado) * defaultEntry[i][2]);
        w3[3]  = w3[3]  + (1 * (expectedOutput[i][2] - resultado) * defaultEntry[i][3]);
        w3[4]  = w3[4]  + (1 * (expectedOutput[i][2] - resultado) * defaultEntry[i][4]);
        w3[5]  = w3[5]  + (1 * (expectedOutput[i][2] - resultado) * defaultEntry[i][5]);
        w3[6]  = w3[6]  + (1 * (expectedOutput[i][2] - resultado) * defaultEntry[i][6]);
        w3[7]  = w3[7]  + (1 * (expectedOutput[i][2] - resultado) * defaultEntry[i][7]);
        w3[8]  = w3[8]  + (1 * (expectedOutput[i][2] - resultado) * defaultEntry[i][8]);
        w3[9]  = w3[9]  + (1 * (expectedOutput[i][2] - resultado) * defaultEntry[i][9]);
        w3[10] = w3[10] + (1 * (expectedOutput[i][2] - resultado) * defaultEntry[i][10]);
        w3[11] = w3[11] + (1 * (expectedOutput[i][2] - resultado) * defaultEntry[i][11]);
        w3[12] = w3[12] + (1 * (expectedOutput[i][2] - resultado) * defaultEntry[i][12]);
        w3[13] = w3[13] + (1 * (expectedOutput[i][2] - resultado) * defaultEntry[i][13]);
        w3[14] = w3[14] + (1 * (expectedOutput[i][2] - resultado) * defaultEntry[i][14]);
        w3[15] = w3[15] + (1 * (expectedOutput[i][2] - resultado) * defaultEntry[i][15]);
        w3[16] = w3[16] + (1 * (expectedOutput[i][2] - resultado) * defaultEntry[i][16]);
        w3[17] = w3[17] + (1 * (expectedOutput[i][2] - resultado) * defaultEntry[i][17]);
        w3[18] = w3[18] + (1 * (expectedOutput[i][2] - resultado) * defaultEntry[i][18]);
        w3[19] = w3[19] + (1 * (expectedOutput[i][2] - resultado) * defaultEntry[i][19]);
        w3[20] = w3[20] + (1 * (expectedOutput[i][2] - resultado) * defaultEntry[i][20]);
        w3[21] = w3[21] + (1 * (expectedOutput[i][2] - resultado) * defaultEntry[i][21]);
        w3[22] = w3[22] + (1 * (expectedOutput[i][2] - resultado) * defaultEntry[i][22]);
        w3[23] = w3[23] + (1 * (expectedOutput[i][2] - resultado) * defaultEntry[i][23]);
        w3[24] = w3[24] + (1 * (expectedOutput[i][2] - resultado) * defaultEntry[i][24]);
        w3[25] = w3[25] + (1 * (expectedOutput[i][2] - resultado) * defaultEntry[i][25]);
        }

    void RecalcularPeso4(int i, int resultado) {

        w4[0]  = w4[0]  + (1 * (expectedOutput[i][3] - resultado) * defaultEntry[i][0]);
        w4[1]  = w4[1]  + (1 * (expectedOutput[i][3] - resultado) * defaultEntry[i][1]);
        w4[2]  = w4[2]  + (1 * (expectedOutput[i][3] - resultado) * defaultEntry[i][2]);
        w4[3]  = w4[3]  + (1 * (expectedOutput[i][3] - resultado) * defaultEntry[i][3]);
        w4[4]  = w4[4]  + (1 * (expectedOutput[i][3] - resultado) * defaultEntry[i][4]);
        w4[5]  = w4[5]  + (1 * (expectedOutput[i][3] - resultado) * defaultEntry[i][5]);
        w4[6]  = w4[6]  + (1 * (expectedOutput[i][3] - resultado) * defaultEntry[i][6]);
        w4[7]  = w4[7]  + (1 * (expectedOutput[i][3] - resultado) * defaultEntry[i][7]);
        w4[8]  = w4[8]  + (1 * (expectedOutput[i][3] - resultado) * defaultEntry[i][8]);
        w4[9]  = w4[9]  + (1 * (expectedOutput[i][3] - resultado) * defaultEntry[i][9]);
        w4[10] = w4[10] + (1 * (expectedOutput[i][3] - resultado) * defaultEntry[i][10]);
        w4[11] = w4[11] + (1 * (expectedOutput[i][3] - resultado) * defaultEntry[i][11]);
        w4[12] = w4[12] + (1 * (expectedOutput[i][3] - resultado) * defaultEntry[i][12]);
        w4[13] = w4[13] + (1 * (expectedOutput[i][3] - resultado) * defaultEntry[i][13]);
        w4[14] = w4[14] + (1 * (expectedOutput[i][3] - resultado) * defaultEntry[i][14]);
        w4[15] = w4[15] + (1 * (expectedOutput[i][3] - resultado) * defaultEntry[i][15]);
        w4[16] = w4[16] + (1 * (expectedOutput[i][3] - resultado) * defaultEntry[i][16]);
        w4[17] = w4[17] + (1 * (expectedOutput[i][3] - resultado) * defaultEntry[i][17]);
        w4[18] = w4[18] + (1 * (expectedOutput[i][3] - resultado) * defaultEntry[i][18]);
        w4[19] = w4[19] + (1 * (expectedOutput[i][3] - resultado) * defaultEntry[i][19]);
        w4[20] = w4[20] + (1 * (expectedOutput[i][3] - resultado) * defaultEntry[i][20]);
        w4[21] = w4[21] + (1 * (expectedOutput[i][3] - resultado) * defaultEntry[i][21]);
        w4[22] = w4[22] + (1 * (expectedOutput[i][3] - resultado) * defaultEntry[i][22]);
        w4[23] = w4[23] + (1 * (expectedOutput[i][3] - resultado) * defaultEntry[i][23]);
        w4[24] = w4[24] + (1 * (expectedOutput[i][3] - resultado) * defaultEntry[i][24]);
        w4[25] = w4[25] + (1 * (expectedOutput[i][3] - resultado) * defaultEntry[i][25]);
        }
}
